COMMENT ⊗   VALID 00005 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	Comments to McCarthy's paper concerning early LISP history
C00009 00003	Comments to McCarthy's paper on LISP history
C00033 00004	7. To come to the end I want to list the development of LISP-implementations.
C00040 00005	Literaure:
C00042 ENDMK
C⊗;
Comments to McCarthy's paper concerning early LISP history

The main problem of early LISP history is we must always ask J. McCarthy for
information. With the exception of Paul Abrahams, nobody has answered my
calls; McCarthy for himself seems to have only D. Parks additional
answer. But Abrahams memories were not very exact - he claims garbage
collection as result of R. Silver's ideas what should be wrong after
informations from him (retrived by McCarthy).

If more people involved in the early days would answer McCarthy or me,
we could come on save ground.  I don't want to say that McCarthy don't
serve right memories.  In all cases I found papers related to the subject some
confirmation for him could retrieved.

I want to compile some problems I see in the current knowledge about early
days of LISP:

1. The true connections resp. relations of McCarthy to FLPL are not very
clear. If he would have done that important work he told us I can't understand
that the FLPL authors mention in their first publicaton (1) only the idea of
M.Minsky and not of mcCarthy. If all of his inventions for LISP-processing on IBB704
were made 1956, we are in trouble in 1957 when nothing happened.

2. If I suppose the work "not" at page 2,11 line from below is misprinted,
McCarthy did some programming for chess in FORTRAN for the IBM704 only
at MIT. We don't know about a (partially) running version of that program.

3. The relations to the FLPL project came in question again if we look to summer
1958 when he was at IBM.

4. McCarthy gives different statements concerning the compiler.  In his
historical remarks he tells that the Brayton-compiler project wasn't
successful but in the CACM paper of 1960 (2) we read about a running compiler.
The later authors of the true compiler, Levin & Hart are not mentioned
in this paper as co-workers. It would be interesting to see the firs
version of the paper (2) in (3).  This is a curious point: new details about
the LISP-systems are added (possibly) but the APPLY-EVAL-function is
indeed wrong (after implementation).

5. The information about the APPLY-EVAL-implementation is very small. A
lot of errors must be fixed, and removed. Who wrote the first program
actually accepted by APPLY?
In which way started the usage of the system?

6. The differences between LISP 1 and LISP 1.5 are not clear.  In McCarthy's list
the differences a.,e. and h. should be rejected if we ready carefully
(a. is in LISP1 and LISP 1.5), the paper (2) mentions e. and H. What is with
c? (2) reports work with floating point numbers - are they lists too?
A shure document would be the LISP 1 manual, of course. But how to find some
example? It seems to me McCarthy for himself didn't get this manual for his
history paper.  It's a good idea to reject differences a. and e and h and to
modify c. in such a way that we say: At the beginning, numbes were been
implemented as lists of digits. Later on this was changed. But the LISP 1 system
couldn't do much arithmetics. LISP 1.5 completed the basic function sortiment.
A point forgotten by McCarthy (th.is "i."): in LISP 1.5 we had arrays which
were not present in LISP 1.

To come to an end we could stress two points: The LISP-system before Russells
implementation of APPLY-EVAL was usable by progrmming in assembly language under
observation of the calling conventions etc. This was done for example by
S. Goldberg and D. Edwards (4) resp. (5).

The LISP language before the implementation was very much FORTRAN.  I'm sure
there was no prog-feature because the most programs were sequential
(the goal was an assembly program) and a special device for separating
sequential work was not needed. Sometimes the programs contained conditional
expressions, sometimes functional arguments (this may be an open question).
The basic fnctions for list processing were added to this special FORTRAN,
or course.  After implementation, the need for prog did arise and a lot of new 
concepts were realized.  The joke of history is here that the inventor for himself
didnit understand or valuate the most of them for years.  Until 1965 he dreamed
about "the language LISP" that could be a same nice language like ALGOL and
his own old language (then nearly garbage). Today he uses still this old language.  But
for the world of users, this isn't LISP.
Comments to McCarthy's paper on LISP history

Before I start with my actually comments let me expess my regret to be
not present at this symposium.  I cannot discuss the reasons why but
I want to stress the fact that only a minimum of blame is cooing to the
organizators.

It seems to me very important that the auditorium should discuss the question of 
the (of course doubtful) usefulness of the hisotyr of programming languages
for the future development of the science of programming languages.  It
seems sometimes a new programming language to be developed every week (or month)
without looking for experiences accumulated at other languages.  The break
down respectively the final failing of a development project of a programming
language (if a world of users is anticipated and then a little community of
fans remains, it is a failing too) seen at different concrete events is, for me,
a pointer (hint) to the  forgotten development of pragmatics as a part of
language theory..

Programming languages are not only sequential strings of characters accepted
by computers. They are mainly languages used by writing (and thinking hopefully)
humans. The programmers communicate, develop and write their programs and
think in a programming language. In this way a programming language is a good 
deal to study as social phenomenon - and here history is always a good approach.

To realize the basic ideas in the intellectual environment of the language
inventor (or designer), to see why special parts of the language were fixed 
at the end in a specific kind and to understand the way the language was and
is used by other programmers can make the feeling for a language and its
comprehension better and deeper.

In this way I understand history of programming languages as a part of a future
science of programming languages containing the current most stressed fields
of syntax and semantics as genuine special sections.

It seems to me - but I've drawn this conclusion only from the list of
invented speakers - that history of a language is understood more as history
of language design.  Here it is rather curious to write this history of
a living subject and only to tell about it's father and mother and the time 
until it's birth.  This is more prehistory, but in case of programming
languages (as for all social phenomenon) this is an important part of
the history.  If we look at FORTRAN, the design period can take a long time.

But it is clear the life begins with the first user.  To use a noncomplete
analogy, programs were seen as hisotyrless entities and their life was
believed to be uninteresting for their developers.  It is not long time
ago that we must accept the fact of a whole life cyclus of programs.
Then it was possible to make clear the influences of later stages in
program's life to program writing and to anticipate different program usages
having the future maintaining and updating activities in eye.

I'm far (at present) from the conclusion drawn in complete analogy we should
develop our programming languages having their later versions and their
ultimate dead in mind.  Here the history will bring results useful in
practical work.

To come to LISP, I want to take my subject in the history after programming
language development.  I can do this because McCarthy has covered all the
topics in a way this can handled on a few pages.  I understand his self
limitation as encouragement for me.  

To sum up his paper:  Before the implementation of EVAL by S. Russell, we had
an informal defined language having much in common with FORTRAN (assignments,
function calls, go-to's, function composition in algebraic resp. symbolic
expressions etc) but showing new elements of expressive power (new
standard functions, recursive definitions, functional arguments, conditional
expressions).  After this important (and not foreseen) even the so-called
S-language became more an more "the language LISP".

The further history of LISP is characterized by the following developments:
Most important for the future LISP users was the insertion of LISP into
interactive environments (using time sharing systems).  This work isn't completed
as we can see in Teitelman's work (6,7,8).  The second theme in LISP
development was and is the enlargement of the language to meet current demands (1).
New data types, language elements (f.es. the NLAMBDA in Interlisp (5))
and new control structures were added. The most advanced systems are here again
INTERLISP and even MACLISP.  On another page we must of course mention the
enlargement of the set of implemented functions.  LISP 1.5 and 130 basic
functions, MACLISP now has some 200, INTERLISP some 300; here we have to
add the implementer supplied LISP functions (Our system, DOS/ES LISP 1.6
has 390 basic functions)

The fourth typical phenomenon in LISP development is its usage as basic
system to implement higher level languages.  Started with MLISP (2), a series
of languages for specific applications and with nicer syntax have been implemented 
in LISP.  Result is that for ex. Sandewall (4) can understand LISP (that is
the S-language) merely as internal program representation; the external notation i
for him open: "There is, however, no commitment as to how the structure is to
be entered..."

As a fifth characteristic we see from time to time that such a higher level
language over LISP is claimed to surpass it's mother LISP.  All this attempts
have had no success until now.  This is because, and this is my 6th point, the
LISP community understands step by step new preferences of LISP, new possibilities
and new concepts.  Clearly all of them were in LISP since 1960 but they are
discovered resp. stressed at different times.  The last thing I want to take
as specific characteristics of LISP-history is its slow but constant spreading
over the computer world.  If we look at books like Highmans (3), LISP should
be dead a lot of time ago.  But new users learn LISP, old implementations
are under charge and new ones are started all the time.  If we take note of this
we are not blind for the drawbacks of LISP.  It may be that the successor
language is under development now somewhere.  But I don't believe.  Let's look
at this candidate.  It will fail again as LISP2 or LISP70...

We want to discuss the points in more detail.

1.  If LISP was developed it wasn't thought to be a dialog language.  It could,
of course, possible to write programs in LISP that use teletypes as external
devices etc.  The fact that LISP is the dialog language comes from its
interpretive work (an accident, we know), its data-structure representation
of programs and the power of the language - we should not forget the function
principle which is very handy for command etc.  When the CTSS was operating
at MIT, very soon attempts were made to have LISP in it.  We are sure that
LISP was interactive at 1963.  At the end of 1963 we know about a second
attempt to have LISP in a time-sharing system: D. Edwards reports on a LISP
system using software-paging on a PDP-1, and this seems to be the
environment of the 2.  MIT time sharting system (J. Denning).  Later some
LISP-implementors have contributed to the development of time-sharing (we don't
mention here J. McCarthy's important work), by develloping such systems (D. Bobrow)
or by studying the needs of interactivity (L.P. Deutsch's work on editors).
We should mention here the work done at Stanford unver McCarthy's direction
(1963-1965), and the implementation of ITS at AI Lab of MIT.

Teitelman's (and the other INTERLISP designer) ideas for user-interfaces in
interactive environments are very important not only for LISP but for all
interactive systems.  His implementation of DWIM, an interactive debugger
and corrector, of the programmers assistant, of CLISP, etc etc are
important steps towards a future programming culture.

2. The usual data structures are numbers, atoms, and lists.  But very soon
it was apparent that arrays can serve as interesting complement to lists.
LISP 1.5 contains them.  A lot of work in language processing then made
D. Bobrow to ask for strings in LISP.  It seems that INTERLISP (at this
time BBN-LIS) had strings first in 1970. (the strings in LISP 1.6 were 
essential items) there were no string manipulation functions).
Today new data structures are used: arrays of diverse types, hash-arrays,
bignums for integers of any precision and hunks - dense vectors of listelements.
INTERLISP reaches the top with user definable datatypes of any new kind.

The external representation of the language today has much in common with
that of 1960. Alternations were first the Quote-character, then the
slasifter (escape character) invented for rereadable LISP-output.
INTERLISP produced the meta "parenthis'" that are brackets.  An important
development was the macrocharacters of LISP 1.6.  For comments in some
systems a special character is used.

Some of the needs of AI research LISP could cover by having new constructs
for directing the parth of control.  MACLISP's global exitts (CATCH & THROW)
and INTERLISP's stack functions are to mention here.  Other demands are not
answered due to a lack of a commonly accepted solution.  Here we must
mention pattern description, pattern matching, pattern envoced function
calls, goal directed function calls etc. etc. The LISP society don't feel
bothered by this situation - the higher level languages show this feature.

3. The function enlargement is clearly visible if we compare the BBN-LISP
on the PDP-1 1965 and INTERLISP today.  As it is always the case, some
functions are indeed redundant (but useful of course).  But mainly functions
are only implemented if they add a new basic operation for a data structure
or if they are too often used as to be new defined all the time.  INTERLISP
has added here the difference between handcoded (in assembly language)
and in LISP written basic functions.

A good LISP system has the following function classes now:  a. functions
for list manipulation, b. predicates for list maniniplation, c. functionals,
d. functions for arithmetic, e. predicates for arithmetic, f. functions for
directing the flow of control g. functions to direct the work of the
system, h. functions for error processing and preventing, i. functions for
the user (testing, editing, measuring, debugging etc., j. functions to do
basic actions of the evaluator (interpreter), k. functions for work with
property lists, l. functions for I/O, m. functions for character and
string manipulation, n. functions associated with the compiler and o.
miscellneous fn's (array f. ex.).

4.  The first higher level language for LISP was MLISP (1968), it offered
some of the characteristics of the M-language but was essential more.
ALGOL-like control constructs and vector data-types are the news of this
language.  At the same time a very related language, RLISP, was developed
inside an algebraic manipulation system (REDUCE).  All systems for formula
manipulation, based on LISP, tried then to offer their users a language
interface related to their former habits.  MACSYMA, SCRATCHPAD and others
are important here.  With PLANNER (1967) a new type of language was
invented.  These languages should have more power than the basic language. 
PLANNER itself was implemented by using the macrocharacter facility of
MACLISP. Later QA4, MLISP2 and QLISP developed the idea of backtracking
and pattern matching further.  Today higher level languages like QLLSP,
CLLSP (Teitelman), MLISP2, RLISP and CGOL (Pratt) are in heavy use.

5. During the time 2 projects have claimed to overcome LISP as basic language
for AI.  This was LISS2 and LISP70.  Hewitt told always his languages PLANNER
and PLASMA are more powerful than LISP but never he actually said that LISP
is of no usage after his languages would be implemented.  We could learn 
a lot if we studies the failing of these 2 projects.  A lot of different
reasons of the negative result is to hear if we look at the literature.  The
machine was too seldom, no famous LISS representative was involved, etc.  The
best summary came from J. Weizenbaum ( ).  He wrote the LISS2 implementers 
had relinquished some of the most important characteristics of LISP 1.5 without
presenting new equivalents.  The result was now at the same level as other 
programming languages (PL/1 for example) and there is no reason for it.

A second important cause for LISP2's dead seems to be the implementation
of higher level languages in LISP at the same time.  So everybody could
implement a product similar to LISP2 and mustn't switch from his good LISP
basic.  The breakdown of LISP70 stays in the stars.  Maybe the simple
accident that the authors left Stanford, maybe other events killed this
highly upcracked project.

6. We saw as an important reason for LISP2's failing a nonawareness of
important LISP concepts.  It seems indeed to be the case that most LISP
users and programmers during the sixties didn't understand resp. see this
concepts.  It is not easy to describe this situation - sometime they used
possibilities which they didn't recognize in their uniqueness.  Some of
this not proper valuated characteristics were the dialog-suitability,
the special property of LISP to have data and programs in the same
external and internal form, the excellent fitness for program testing,
development etc. due to interpretation... To mention another thing: Always
the LISP programmers had written their programs by creating sets of functions
for some basic actions and then use these by themselves or by offering
them other users.  But nobody has developed the idea of virtual machines in
this environment clearly using this idea every day.
May be this is the place for a special remark.  McCarthy mentioned in his
paper that no user society was ever founded and no promoting group
has distributed LISP or has done marketing for it.  There are other people
that speak all of their life about an only invention they made and make in
this way all world to speak about them.

In contrary, we see the most of the LISP ideas unknown in circles of users
of other programming languages and they work to invent them anew.  It seems
to be a fact worth to deplore that a lot of ideas  and concepts connected
with one special programming language don't have a widespread public notice.
We have LISP-worlds and FORTRAN-worlds and PASCAL worlds and so on...
(It seems to me that the LISP'les with their openness to language
implementation are looking a little bit more over their fence than others...)


7. To come to the end I want to list the development of LISP-implementations.

1962:	LISP 1.5 at MIT Cambridge
1963/64:LISP 1.5 at MIT Camridge and Stanford (IBM7090)
	LISP 1.5 at Air Force Res. Labs Cambridge (Univac M460)
	LISP 1.5 at SDS Santa Monica (Q32)
	LISP 1.5 at III (by L.P. Deutsch) (pdp-1)
	LISP 1.5 at MIT (pdp-1)
	LISP 1.5 at Yale University (Hawkinson) (IBM 709)
	start of LISP work at Mexico City
	v.d. Poel (Netherlands) studies LISP
1965:	CONVERT (Guzman) based on LISP BBN-LISP (pdp-1)
1966:	LISP 1.5 at MIT (pdp-6)
	LISP 1.5 at Oslo (J.Kent) (CDC3300)
	start of LISP work at Waterloo 
1967:	LISP 1.6 at MIT Cambridge and Stanford (pdp-6)
	LISP 1.5 at BBN (SDS940)
	LISP 1.5 at U of Cal Berkeley (Deutsch)(SDS940)
	LISP 1.5 at Stanford (IBM360)
	LISP 1.5 at Delft (Netherlands) (EL X8)
	LISP 1.5 at Warsaw (Poland) (Gier)
1968:	start of LISP work in Sweden (Urmi transp. Kents (CDC 3300 LIS)
	LISP 1.5 at Austin (CDC6000)
	start of LISP work at USSR (BESM-6)
	start of LISS work at Hungary
	LISP/360 is transported to France
	ATLAS LISP (London, Imperial College)
	LISP 1.5 at Delft (Netherlands) (pdp-8)
1969:	LISP Bullltin mentions the following systems:
	LISP 1.5 at SDC (Santa Monica) (IBM/360,OS:ADEPT)
	LISP 1.5 at Rensselaer Polytechnic Inst. Troy, N.Y. (IBM/360,OS,DOC)
	LISP 1.5 at IBM Yorktown Heights (IBM/360.91,OS)
	LISP 1.6 at MIT (pdp-6/pdp-10,OS:ITS)
	LISP 1.6 at Stanford (pdp-6/pdp-10,OS:10/50)
	LISP 1.5 at Waterloo, Canada (CDC3300)
	LISP 1.5 at Austin (CDC6600)
	LISP 1.5 at BBN (SDS940)
	BESM-6-LISP is running (Moscow, USSR)
	LISP F1 at Uppsala (Sweden) (Fortran!)
1970	LISP 1.5 at Dresden (GDR) (BSER-R40,DOS)
	BBN-LISP (LISP 1.5) at BBN for pdp-10
	LISP 1.5 at Univ. of Wisconsin (Univac 1108)
	MACLISP at MIT
1971	LISP 1.5 at Prague (Czechoslowakia) (Tesla 200)
1972	LISP 1.5 at Marburg (Germany) (TR440 or pdp-8)
	LISP 1.6 at Dresden (GDR) (ESER-R40,DOS)
1973	UCI-LISP at USC (pdp-10)
	LISP 1.5 at Berlin (Germany) (TR440)
	LISP 1.5 at Poznan (Poland) (K-202)
	LISP 1.5 at Oslo (Norway) (CDC3300)
	LISP 1.5 at Leningrad (USSR) (Odra 1305)
	LISP 1.5 (subset) at Budapest (Hungary) (R10)
	LISP F2 at Uppsala (Sweden) (Fortran!)
	INTERLISP at BBN and XEROX (pdp-10)
	UT-LISP at Austin (CDC6600)
1974	LISP 1.8 at Tokyo (Japan) (Toshiba 5600)
	start of INTERLISP for IBM/360 at Uppsala (Sweden)
	LISP 1.5 at Poznan (Poland) (Odra 1204)
1975	LISP FINT at Bonn (Germany) (Fortran!)
	LISP 1.5 at Munich (Germany) (Tr440)
	LISP 1.5 at Moscow (USSR) (ESER-R20/R30,DOS)
	start of MAGMA'LISP at Pisa (Italy) (IBM/360;Fortran)
	start of transport of INTERLISS to Siemens 4004
	start of LISP for ESER-R20/R30 - OS.MVT at Leningrad (USSR)
	LISP 1.5 at Erlangen (Germany) (Tr440)
1976	LISP F3 at Uppsala (Sweden) (Fortran)
	LISP 1.6 at Warsaw (Poland) (Odra 1305)
	LISP 1.5 at Nowosibirsk (USSR) - start 1969, russian function names
	LISP 1.9 at Tokyo (Japan) (Toshiba 5600)
	LISP 1.5 at Budapest (Hungary) (R10)
	MACLISP at Stuttgart (Germany) (TR440)
1977	start of work for INTERLISS on Honeywell H80 at Budapest (Hungary)
	LISP/370 at IBM Yorktown Heights (IBM/370)
	INTERLISP at Edinburgh (GB) (ICL 4)
1978	LISP 1.5 at Grenoble (France) (IRIS 80)

further undated systems:
	LISP 1.6 for B6700 Mexico City
	LISPITO at Mexico City
	INTERLISP for B6700
	LISP 1.5 for pdp-8 at Tokyo (Japan)
	VLISP for pdp-10 at Paris (France)
	TLISP at Toulouse (France)
	LISP T1600 at Paris (France)
	LISP 1.5 for Siemens 4004 at Regensburg (Germany)
	LISP 1.5 at Bonn (Germany)
There are some forgotten systems in Japan (HLISP,LIPQ).

The most used systems are:
	STANFORD LISP 1.5
	UTLISP for CDC6600
	BESM-6-LISP
	LISP 1.6 for pdp-10 at Stanford
	INTERLISP (on different computers)
	LISP 1.5 for UNIVAC 1108
	DOS/ES LISP 1.6 for ESER (R40)
Literaure:

1. D.Bobrow: Requirements of advanced programming systems for list processing,
Comm ACM 15,7,618-627 (1972)

2. H.Enea: MLISP (360/67), Stanford University, CS92, 1968.

3. B. Highman: Programming languages - a comparative study, London 1967.

4. E. Sandewall: Some observations on conceptual programming, Uppsala 1975.

5. W. Teitelman: INTERLISP reference manual, Palo Alto, 1975.

6. W. Teitelman: Toward a programming laboratory, 1.IJCAI 1969.

7. W. Teitelman: Automated programming - the programmers assistant, Proc. FJCC, 1972.

8. W. Teitelman: A display oriented programmers assistant, 5IJCAI, 1977.

9. J. Weizenbaum: Review 67-22, IEEE Trans.el.comp., p. 236-239, 1967.


It is clear that a short paper cannot cover the time from 1962 to 1978. A Book
concerning LISP and including LISP history is under work and will go in print
in October 1978.  If some datas are wrong, or some systems lost, please help
me and write me the needed information.

			Herbert Stoyan
			DDR-806 Dresden
			Togliattistr.40
			DDR-GDR (East Germany)